שיעור מספר 6: מקושרים

Transcription

1 שיעור מספר 6: מקושרים וולף ליאור בית הספר למדעי המחשב

2 על סדר היום נתחיל בדוגמא נאיבית של מבנה מקושר נכליל את המבנה ע"י הכללת טיפוסים נדון בייצוג הכרות אינטימית בשפת התכנות נדון בהפשטת מעבר סידרתי על נתונים והשלכותיו 2

3 על סדר היום נתחיל בדוגמא נאיבית של מבנה מקושר רשימה מקושרת נכליל את המבנה ע"י הכללת טיפוסים טמפלייטים נדון בייצוג הכרות אינטימית בשפת התכנות מחלקות פנימיות נדון בהפשטת מעבר סידרתי על נתונים והשלכותיו איטרטורים 3

4 מבנים מקושרים כדי לייצג מבנים מקושרים, כגון רשימה מקושרת, עץ, וכדומה, מגדירים מחלקות שכוללות שדות שמתייחסים לעצמים נוספים מאותה מחלקה )ולפעמים גם למחלקות נוספות (. כדוגמא פשוטה ביותר, נגדיר מחלקה IntCell שעצמים בה מייצגים אברים ברשימות מקושרות של שלמים. המחלקה מייצאת בנאי ליצירת עצם כאשר התוכן )שלם( והאבר הבא הם פרמטרים. המחלקה מייצאת שאילתות עבור התוכן והאבר הבא, ופקודות לשינוי האבר הבא, ולהדפסת תוכן הרשימה מהאבר הנוכחי השדות מוגדרים כפרטיים מוסתרים מהלקוחות המבנה IntCell אנלוגי למבנה cons משפת :Scheme car אנלוגי ל cont() cdr אנלוגי ל next() 4

5 class IntCell public class IntCell { private int cont; private IntCell next; public IntCell(int cont, IntCell next) { this.cont = cont; this.next = next; public int cont() { return cont; 5

6 class IntCell public IntCell next() { return next; public void setnext(intcell next) { this.next = next; public void printlist() { System.out.print("List: "); משתנה העזר של הלולאה הוא מטיפוס IntCell for (IntCell y = this; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); 6

7 מחלקה לביצוע בדיקות כדי לבדוק שהמחלקה שכתבנו פועלת כנדרש, נכתוב מחלקה התחלתית לבדיקה, שתכיל השרות הראשי.main בהמשך הקורס נעסוק בנושא בדיקות (testing) אך כרגע נציין שעלינו לבחור מקרי בדיקה שמכסים אפשרויות שונות כדי שנוכל לגלות שגיאות )אם יש( חשוב! שגיאות של מחלקה או שרות מוגדרות בהקשר של החוזה של המחלקה. אם למחלקה )או לשרות שלה( אין חוזה מפורש לא ברור מהי ההתנהגות ה"נכונה" במקרי קצה בהרצאה היום נסתפק באינטואיציה שיש לנו לגבי רשימות מקושרות 7

8 מחלקה לביצוע בדיקות public class Test { public static void main(string[] args) { IntCell x = null; IntCell y = new IntCell(5,x); y.printlist(); IntCell z = new IntCell(3,y); z.printlist(); z.setnext(new IntCell(2,y)); z.printlist(); y.printlist(); 8

9 מחלקה לביצוע בדיקות הפלט List: 5 List: 3 5 List: List: 5 איך ניצור מבנה מקושר של תווים? או של מחרוזות? יצירת מחלקה חדשה כגון StringCell או CharCell תשכפל הרבה מהלוגיקה הקיימת ב IntCell יש צורך בהפשטת הטיפוס int מטיפוס הנתונים Cell היינו רוצים להכליל את הטיפוס Cell לעבוד עם כל סוגי הטיפוסים 9

10 מחלקות ושרותים מוכללים )גנריים( החל מגירסא 1.5 )נקראת גם ) 5.0 ג'אווה מאפשרת הגדרת מחלקות גנריות ושרותים גנריים )Generics( מחלקה גנרית מגדירה טיפוס גנרי, שמציין אחד או יותר משתני טיפוס variables) (type בתוך סוגריים משולשים. עקב ההוספה המאוחרת לשפה )והדרישה שקוד שנכתב קודם יוכל לעבוד ביחד עם קוד חדש(, ומשיקולים של יעילות המימוש, כללי השפה לגבי טיפוסים גנריים הם מורכבים. 10

11 מחלקות ושרותים מוכללים )גנריים( רעיון דומה קיים גם בשפת התכנות ++C ב ++C נקראת תכונה זו תבנית )template( כרגע נציג רק את המקרה הפשוט. לדון בנושא ביתר פירוט. בהמשך נחזור דוגמא ראשונה הכללה של המחלקה IntCell לייצוג תא שתוכנו מטיפוס פרמטרי T, כך שכל התאים ברשימה הם מאותו הטיפוס. 11

12 Cell <T> public class Cell <T> { private T cont; private Cell <T> next; public Cell (T cont, Cell <T> next) { this.cont = cont; this.next = next; 12

13 Cell <T> public T cont() { return cont; public Cell <T> next() { return next; public void setnext(cell <T> next) { this.next = next; 13

14 Cell <T> public void printlist() { System.out.print("List: "); for (Cell <T> y = this; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); 14

15 מה השתנה במחלקה? לכותרת המחלקה נוסף משתנה הטיפוס T מקובל ששמות משתני טיפוס הם אות גדולה אחת אולם זו אינה דרישה תחבירית, ניתן לקרוא למשתנה הטיפוס בשם משמעותי הטיפוס שמוגדר הוא <T> Cell הטיפוס של כל שדה, פרמטר, משתנה זמני, של שרות שהיה int יוחלף ב T וכל טיפוס מוחזר הטיפוס של כל שדה, פרמטר, משתנה זמני, של שרות שהיה Cell יוחלף ב Cell<T> וכל טיפוס מוחזר 15

16 שימוש בטיפוס גנרי כדי להשתמש בטיפוס גנרי יש לספק, בהצהרה על משתנה, ובקריאה לבנאי, טיפוס קונקרטי עבור כל משתנה טיפוס שלו. לדוגמא: <Integer> Cell באנלוגיה להגדרת שרות וקריאה לו, משתנה טיפוס בהגדרת המחלקה מהווה מעין פרמטר פורמלי, והטיפוס הקונקרטי הוא מעין פרמטר אקטואלי. 16

17 שימוש בטיפוס גנרי הטיפוס הקונקרטי חייב להיות טיפוס הפנייה, אינו יכול להיות פרימיטיבי. כלומר אם רוצים ליצור למשל תאים שתוכנם הוא מספר שלם, לא ניתן לכתוב <int> Cell לצורך זה נזדקק לטיפוסים עוטפים (wrapper type) 17

18 טיפוסים עוטפים (wrappers) לכל טיפוס פרימיטיבי קיים בג'אווה טיפוס הפנייה מתאים: ל- float העוטף, Float ל- double העוטף Double וכו' int המתאים ל, Integer ו- char יוצאי דופן: Character המתאים ל- כל הטיפוסים העוטפים מקובעים )immutable( הטיפוסים העוטפים שימושיים כאשר יש צורך בעצם ביצירת אוספים של ערכים, ובשימוש בטיפוס גנרי( )למשל 18

19 Boxing and Unboxing ניתן לתרגם טיפוס פרימיטיבי לטיפוס העוטף שלו )boxing( ע"י קריאה לבנאי המתאים: char pc = 'c'; Character rc = new Character(pc); ניתן לתרגם טיפוס עוטף לטיפוס הפרימיטיבי המתאים )unboxing( ע"י שימוש במתודות xxxvalue המתאימות: Float rf = new Float(3.0); float pf = rf.floatvalue(); מאפשרת מעבר אוטומטי בין טיפוס פרימיטיבי לטיפוס העוטף שלו: ג'אווה 1.5 Integer i = 0;// autoboxing int n = i; // autounboxing if(n==i) // true i++; // i==1 System.out.println(i+n); // 1 19

20 בחזרה לשימוש בטיפוס גנרי נראה מחלקה שמשתמשת ב <T> Cell שהשתמשה ב : IntCell, שהיא אנלוגית למחלקה public class TestGen { public static void main(string[] args) { Cell <Integer> x = null; Cell <Integer> y = new Cell<Integer>(5,x); y.printlist(); Cell<Integer> z = new Cell <Integer>(3,y); z.printlist(); z.setnext(new Cell <Integer>(2,y)); z.printlist(); y.printlist(); 20

21 עוד על שימוש בטיפוס גנרי ניתן להגדיר משתנה )שדה, משתנה זמני, פרמטר( מהטיפוס <Integer>> Cell <Cell גם מה מייצג הטיפוס הזה? דוגמא של הצהרה עם אתחול: Cell <Cell <Integer> > q = new Cell <Cell <Integer>> (new Cell<Integer> (8,null), null); 21

22 ? מי אתה Cell<T> האם Cell<T> באמת מייצג רשימה מקושרת? בשפת Scheme התשובה היא כן. אולם ב Java אמצעים טובים יותר להפשטת טיפוסים יש בשפה Cell אינו רשימה הוא תא ניתן )וצריך!( לבטא את שני הרעיונות רשימה ותא כטיפוסים בשפה עם תכונות המתאימות לרמת ההפשטה שלהן נציג את המחלקה MyList<T> המייצגת רשימה 22

23 קרוב ראשון ל- MyList<T> public class MyList <T> { private Cell <T> head; public MyList (Cell <T> head) { this.head = head; המחלקה נקראת MyList ולא List כדי שלא נתבלבל בינה ובין java.util.list מהספרייה הסטנדרטית של Java public Cell<T> gethead() { return head; public void printlist() { System.out.print("List: "); for (Cell <T> y = head; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); 23

24 חסרונות המימוש מימוש הרשימה אמור להיות חלק מהייצוג הפנימי שלה ומוסתר מהלקוח במימוש המוצע לקוחות המחלקה MyList צריכים להכיר גם את המחלקה Cell Cell <Integer> x = null; Cell <Integer> y = new Cell<Integer>(5,x); Cell <Integer> z = new Cell<Integer>(3,y); MyList<Integer> l = new MyList<Integer>(z); l.printlist(); להחליף את המימוש לרשימה הדבר פוגע בהפשטת רשימה מקושרת למשל, אם בעתיד ירצה ספק MyList דו-כיוונית 24

25 - קרוב שני MyList <T> public class MyList <T> { private Cell <T> head; private Cell <T> curr; public MyList <T> (T... elements) { this.head = null; for (int i = elements.length-1; i >= 0; i--) { head = new Cell<T>(elements[i], head); curr = head; public boolean atend(){ return curr == null; */ public void advance() { curr = curr.next(); 25

26 - המשך MyList <T> */ public T cont() { return curr.cont(); השרות אינו מחזיר את התא הנוכחי )טיפוס )Cell אלא את התוכן של התא הנוכחי )T( */ public void addnext(t elem) { Cell<T> temp = new Cell<T>(elem, curr.next()); curr.setnext(temp); public void printlist() { System.out.print("List: "); for (Cell <T> y = head; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); ידפיס את תוצאת הפעלת השרות y.cont() על T של הטיפוס tostring 26

27 MyList <T> כעת לקוח הרשימה )<T> )MyList מחלקת העזר :Cell<T> אינו מודע לקיום MyList <Integer> l = new MyList <Integer>(3,5); l.printlist(); l.advance(); l.addnext(4); l.printlist(); 27

28 ע) MyList <T> איך נממש את השרות (x addhere(t האיבר x לפני המקום הנוכחי ברשימה: )המספרים הם רק דוגמא לתוכן( שרות המוסיף את בשונה מהשרות addnext() אנו צריכים לשנות את ההצבעה לתא.curr לשם כך ניתן לנקוט כמה גישות: גישה א': תחזוקה של prev נוסף על curr גישה ב': נרוץ מתחילת הרשימה עד המקום אחד לפני הנוכחי "י השוואת next() של כל תא ל )curr גישה ג': החלפת תכני התאים 3 head curr head curr 54 28

29 יחסים אינטימיים גישות א' ו- ב' פשוטות יותר רעיונית אך פחות אלגנטיות )תחזוקה, ביצועים( ננסה לממש את גישה ג */ public void addhere(t elem) { Cell<T> temp = new Cell<T>(elem, curr.next()); addnext(elem); curr.setnext(temp); curr.next().cont temp.cont = curr.cont(); = curr.cont(); curr.cont = elem; אולי במקרה זה דרישת הפרטיות של נראות של השדה cont היא מוגזמת? הקלת הנראות של שדה אינה מוצדקת ואולם, המחלקה Cell<T> היא מחלקת עזר של <T> MyList ולכן יש הצדקה למתן הרשאות גישה חריגות ל- <T> MyList לשדותיה הפרטיים של Cell<T> גם לו היתה ל Cell המתודה setcont() ניתן היה לאמר כי לאור השימוש התכוף שעושה הרשימה בשרותי התא, ניתן היה משיקולי יעילות לאפשר לה גישה ישירה לשדה זה 29

30 יחסים אינטימיים ב Java אם Cell ו MyList באותה חבילה אפשר להשתמש בנראות חבילה אבל כל מחלקה אחרת בחבילה תוכל גם היא לגשת לפריטים האלה של Cell ניתן להגדיר אינטימיות בין מחלקות ב Java ע"י הגדרת אחת המחלקות כמחלקה פנימית של המחלקה האחרת מחלקות פנימיות הן מבנה תחבירי בשפת Java המבטא בין השאר הכרות אינטימית הערה על דרגות נראות: דרגת הנראות ב Java היא ברמת המחלקה. כלומר עצם מטיפוס כלשהו יכול לגשת גם לשדות הפרטיים של עצם אחר מאותו הטיפוס ניתן היה לחשוב גם על נראות ברמת העצם )לא קיים ב )Java 30

31 מחלקות פנימיות )מקוננות( Inner (Nested) Classes

32 Inner Classes מחלקה פנימית היא מחלקה שהוגדרה בתחום Scope( בין המסולסליים( של מחלקה אחרת public class House { private String address; public class Room { private double width; private double height; דוגמא: שימוש לב! Room אינה שדה של המחלקה House 32

33 מחלקות פנימיות הגדרת מחלקה כפנימית מרמזת על היחס בין המחלקה הפנימית והמחלקה העוטפת: למחלקה הפנימית יש משמעות רק בהקשר של המחלקה החיצונית למחלקה הפנימית יש הכרות אינטימית עם המחלקה החיצונית המחלקה הפנימית היא מחלקת עזר של המחלקה החיצונית Cell ו- List דוגמאות: Iterator ו- Collection Brain ו- Body מבני נתונים המוגדרים ברקורסיה: 33

34 Inner Classes ב Java כל מופע של עצם מטיפוס המחלקה הפנימית צריך להיות משויך לעצם מטיפוס המחלקה העוטפת השלכות תחביר מיוחד לבנאי לעצם מטיפוס המחלקה הפנימית יש שדה הפנייה שמיוצר אוטומטית לעצם מהמחלקה העוטפת כתוצאה מכך יש למחלה הפנימית גישה לשרותים )אפילו פרטיים!( של המחלקה העוטפת 34

35 Inner Classes public class House { private String address; public class Room { // hidden reference to a House private double width; private double height; public String tostring(){ return "Room inside: " + address; 35

36 Inner Classes public class House { private String address; private double height; public class Room { // hidden reference to a House private double height; public String tostring(){ Height of House Height of Room Height of Room Same as this.height return "Room height: " + height + " House height: " + House.this.height; 36

37 יצירת מופעים כאשר המחלקה החיצונית יוצרת מופע של עצם מטיפוס המחלקה הפנימית אזי העצם יווצר בהקשר של העצם היוצר כאשר עצם מטיפוס המחלקה הפנימית נוצר מחוץ למחלקה העוטפת, יש צורך בתחביר מיוחד 37

38 יצירת מופע ע"י המחלקה החיצונית public class House { private String address; public void test() { Room r = new Room(); System.out.println( r ); public class Room {... 38

39 יצירת מופע שלא ע"י המחלקה החיצונית public class Test { public static void main(string[] args){ House h = new House(); House.Room r = h.new Room(); outerobject.new InnerClassName 39

40 Static Nested Classes ניתן להגדיר מחלקה פנימית כ static ובכך לציין שהיא אינה קשורה למופע מסוים של המחלקה העוטפת הדבר אנלוגי למחלקה שכל שרותיה הוגדרו כ static משמשת כספריה עבור מחלקה מסוימת והיא בשפת ++C יחס זה מושג ע"י הגדרת יחס friend 40

41 public class House { private String address; public static class Room { public String tostring(){ public class Test { return Room + address; public static void main(string[] args){ Error: this room is not related to any house Not related to any house House.Room r =... new House.Room(); new OuterClassName.InnerClassName 41

42 הגנה על מחלקות פנימיות סטאטיות אם המחלקה הפנימית אינה ציבורית )אינה מוגדרת,)public הטיפוס שלה מוסתר, אבל עצמים מהמחלקה אינם מוסתרים אם יש התייחסות אליהם public class Outer { private static class Inner implements SomeI { public static SomeI getinner() { return new Inner (); SomeI i = new Outer.Inner(); SomeI i = Outer.getInner(); //error // ok 42

43 מחלקות מקומיות - מחלוקת פנימיות בתוך מתודות ניתן להגדיר מחלקה פנימית המחלקה החיצונית בתוך מתודה של הדבר מגביל את תחום ההכרה של אותה מחלקה לתחום אותה המתודה בלבד המחלקה הפנימית תוכל להשתמש במשתנים מקומיים של המתודה רק אם הם הוגדרו כ final )מדוע?( 43

44 מחלקות מקומיות public class Test {... public void test () { class Info { private int x; public Info(int x) {this.x=x; public String tostring() { return ** + x + ** ; ; Info inf1 = new Info(0); System.out.println(inf1); 44

45 שימוש במשתנים מקומיים public class Test { public void test (int x) { final int y = x+3; class Info { public String tostring(){ return ** + y + *** ; ; System.out.println( new Info()); 45

46 מחלקות אנונימיות בעזרת מחלקות פנימיות ניתן להגדיר מחלקות אנונימיות מחלקות ללא שם מחלקות אנונימיות שימושיות מאוד במערכות מונחות ארועים )כגון )GUI וילמדו בהמשך הקורס 46

47 הידור של מחלקות פנימיות המהדר )קומפיילר( יוצר קובץ.class עבור כל מחלקה. מחלקה פנימית אינה שונה במובן זה ממחלקה רגילה שם המחלקה הפנימית יהיה Outer$Inner.class אם המחלקה הפנימית אנונימית, שם המחלקה שיוצר הקומפיילר יהיה Outer$1.class 47

48 Cell חזרה ל MyList ו כדי להסתיר מהלקוח של הרשימה את הייצוג הפנימי, את Cell כמחלקה מקוננת, פרטית בתוך MyList האם מחלקה פנימית סטטית או לא? אפשרות אחת: Cell אינה סטטית נכתוב אז כל עצם מסוג Cell משויך לעצם MyList כלומר לרשימה מסוימת, ומאפשר לעצם להכיר את הרשימה בה הוא מופיע. אבל מה נעשה אם הוא יעבור לרשימה אחרת? למעשה זה בלתי אפשרי! האבר )התוכן( יכול להיות מוכנס לרשימה אחרת, אבל לא העצם מטיפוס Cell אפשרות שנייה: Cell סטטית מה ההשלכות מבחינת הגנריות? 48

49 רשימה עם מחלקה מקוננת אם Cell מחלקה מקוננת לא סטטית בתוך MyList היא לא חייבת להיות מוגדרת כגנרית. טיפוס התוכן של ה Cell נקבע על פי הפרמטר האקטואלי של עצם ה MyList המתאים. כלומר הרשימה קובעת את סוג אבריה, וכל האברים שנוצרים עבור רשימה מסוימת שותפים לאותו קצת יותר קל לכתוב את הקוד הערה: נראות השדות והשרותים של מחלקה מקוננת פרטית אינה משמעותית )בכל מקרה ידועים למחלקה העוטפת ורק לה(. 49

50 public class MyList <T> { private class Cell { private T cont; private Cell next; public T cont() { return cont; private Cell head; private Cell curr; public MyList (...) {... public boolean atend(){ return curr == null; public Cell next() { return next; */ public void advance() { curr = curr.next(); 50

51 רשימה עם מחלקה מקוננת סטטית אם Cell סטטית היא חייבת להיות גנרית, כי אחרת, עבור private T cont; נקבל הודעת שגיאה Cannot make a static reference to the non-static type T כי אם Cell סטטית, היא לא מתייחסת לעצם מטיפוס,MyList שטיפוס האבר שלו נקבע ביצירתו, אלא למחלקה <T> MyList שבה לא נקבע טיפוס קונקרטי ל T אם כן, מה הפרמטר הגנרי שלה? T או אחר? שתי האפשרויות הן חוקיות, אבל צריך להבין שבכל מקרה אלה שני משתנים שונים, והשימוש עלול להיות מבלבל 51

52 public class MyList <T> { private static class Cell<S> { private S cont; private Cell <S> next; public Cell (S cont, Cell <S> next) { this.cont = cont; this.next = next; public S cont() { return cont; private Cell <T> head; private Cell <T> curr; public MyList (...) { public boolean atend(){ return curr == null; */ public void advance() { curr = curr.next();... 52

53 דיון: printlist() printlist() היא שרות גרוע בעיה: השרות פונה למסך זוהי החלטה שיש לשמור "לזמן קונפיגורציה". אולי הלקוח מעוניין להדפיס את המידע למקור אחר פתרון: שימוש ב tostring שרות זה יחזיר את אברי הרשימה כמחרוזת והלקוח יעשה במחרוזת כרצונו בעיה: השרות מכתיב את פורמט הדפסה )כותרות, רווחים, שורות חדשות( ומגביל את הלקוח לפורמט זה. הלקוח לא יכול לאסוף מידע זה בעצמו שכן הוא אפילו לא מכיר את המחלקה Cell 53

54 Iterator Design Pattern נפתור בעיה זו ע"י שימוש בתבנית התיכון עיצוב( Iterator )תבנית Iterator אינו חלק משפת התכנות אלא הוא מייצג קונספט, רעיון, קלישאה תכנותית שמאפשרת לייצג את רעיון סריקת מבנה נתונים כללי בשפות תכנות מוכוונות עצמים )#C,++C( Java, ממומשים איטרטורים שימושיים כטיפוס בספריה הסטנדרטית 54

55 איטרטור )סודר? אצן? סורק?( איטרטור הוא הפשטה של מעבר כלשהו כדי לבצע פעולה ישירה על מבנה נתונים, כיצד הוא מיוצג על מבנה נתונים יש לדעת גישה בעזרת איטרטור למבנה הנתונים מאפשרת למשתמש לסרוק מבנה נתונים ללא צורך להכיר את המבנה הפנימי שלו נדגים זאת על שני מבני נתונים המחזיקים תווים 55

56 הדפסת מערך )אינדקסים( char[] letters = {'a','b','c','d','e','f'; void printletters() { System.out.print("Letters: "); גישה בעזרת משתנה העזר לנתון עצמו for (int i=0 ; i < letters.length ; i++) { System.out.print(letters[i] + " "); System.out.println(); בדיקה: האם גלשנו הגדרת משתנה עזר ואתחולו קידום משתנה העזר )מעבר לאיבר הבא( 56

57 הדפסת רשימה מקושרת public class MyList<T> {... public void printlist() { System.out.print("Letters : "); for (Cell<T> y = head; y!= null ; y = y.getnext()) { System.out.print(y.getCont() + " "); קידום משתנה העזר )מעבר לאיבר הבא( גישה בעזרת משתנה העזר לנתון עצמו System.out.println(); בדיקה: האם גלשנו הגדרת משתנה עזר ואתחולו a b c d e f 57

58 הכרות אינטימית עם מבנה הנתונים 2 הדוגמאות הקודמות חושפות ידע מוקדם שיש לכותבת פונקצית ההדפסה על מבנה הנתונים: היא יודעת איפה הוא מתחיל ואיפה הוא נגמר היא מכירה את מבנה הטיפוס שבעזרתו ניתן לקבל את המידע השמור במצביע היא יודעת איך לעבור מאיבר לאיבר שאחריו בדוגמת הרשימה המקושרת כותבת המחלקה MyList )הספקית( היא זו שכתבה את מתודת ההדפסה זה אינו מצב רצוי - זהו רק מקרה פרטי של פעולה אחת מני רבות שלקוחות עשויים לרצות לבצע על מחלקה. על המחלקה לספק כלים ללקוחותיה לבצע פעולות כאלו בעצמם 58

59 האיטרטור איטרטור הוא בעצם מנשק )interface( המגדיר פעולות יסודיות שבעזרתן ניתן לבצע מגוון רחב של פעולות על אוספים ב Java טיפוס יקרא פעולות: Iterator בדיקה האם גלשנו )hasnext()( קידום )next()( גישה לנתון עצמו )next()( הסרה של נתון )remove()( אם ניתן לבצע עליו 4 59

60 האיטרטור כן, זה נורא! next() היא גם פקודה וגם שאילתה ממש כשם שמימושים מסוימים של pop() על מחסנית גם מסירים את האיבר העליון וגם מחזירים אותו בשפות אחרות c++( או :)Eiffel יש הפרדה בין קידום משתנה העזר והגישה לנתון remove() אינה חלק משרותי איטרטור )וכך גם אנו סבורים( 60

61 אלגוריתם כללי להדפסת אוסף נתונים נדפיס את האיברים השמורים במבנה נתונים collection כלשהו: for (Iterator iter = collection.iterator(); iter.hasnext( ); ) { גישה בעזרת System.out.println(iter.next()); משתנה העזר לנתון וקידומו לאיבר הבא מבנה הנתונים עצמו אחראי לספק ללקוח איטרטור תיקני ממחלקה שמממשת את ממשק )Iterator המאותחל לתחילת מבנה הנתונים )עצם אם נרצה שהמחלקה MyList תספק ללקוחותיה את האפשרות לסרוק את כל האיברים ברשימה, עלינו לכתוב לה Iterator בדיקה: האם גלשנו הגדרת משתנה עזר ואתחולו 61

62 MyListIterator תקני class MyListIterator<S> implements Iterator<S> { public MyListIterator(Cell<S> cell) { this.curr = cell; public boolean hasnext() { return curr!= null; public S next() { S result = curr.getcont(); curr = curr.getnext(); return result; public void remove() { // must be implemented private Cell<S> curr; 62

63 MyList<T> מספקת איטרטור ללקוחותיה public class MyList<T> implements Iterable<T> { //... public Iterator<T> iterator() { return new MyListIterator<T>(head); מחלקות המממשות את המתודה iterator() בעצם מממשות את המנשק Iterable<T> המכיל מתודה זו בלבד הצימוד בין MyList ו- MyListIterator חזק. על כן מקובל לממש את האיטרטור כמחלקה פנימית של האוסף שעליו הוא פועל כעת הלקוח יכול לבצע פעולות על כל אברי הרשימה בלי לדעת מהו המבנה הפנימי שלה 63

64 printsquares public void printsquares( Iterable<Integer> MyList<Integer> list ds ) { for (Iterator<Integer> iter = list.iterator(); ds iter.hasnext();) { int i = iter.next(); Autounboxing System.out.println(i*i); What is the output for: System.out.println(iter.next()*iter.next()); )שמרו לכן על הפרדה בין פקודות לשאיתות( הלקוח מדפיס את ריבועי אברי הרשימה בלי להשתמש בעובדה שזו אכן רשימה טיפוס הארגומנט MyList<Integer> יכול להיות מוחלף בשם המנשק < Iterable<Integer,ואז הלקוח לא ידע אפילו את שמו של טיפוס מבנה הנתונים 64

65 for/in (foreach) לולאת for שמבצעת את אותה פעולה על כל אברי אוסף נתונים כלשהו כה שכיחה, עד שב Java 5.0 הוסיפו אותה לשפה בתחביר מיוחד )for/in( הקוד מהשקף הקודם שקול לקוד הבא: public void printsquares(mylist<integer> list) { for (int i : list) System.out.println(i*i); יש לקרוא זאת כך: "לכל איבר i מטיפוס int שבאוסף הנתונים "...list אוסף הנתונים list חייב לממש את המנשק Iterable 65

66 for/in (foreach) ראינו כי מערכים מתנהגים כטיפוס :Iterable int[] arr = {6,5,4,3,2,1; for (int i : arr) { System.out.println(i*i); שימוש נכון במבנה for/in מייתר רבים משימושי האיטרטור 66